#-*- coding: utf-8 -*-
from ListeChainee import *

class ListeChainee2(ListeChainee):
    """
    Version améliorée de la classe ListeChainee, elle hérite de toutes 
    les méthodes normales et implémente en plus une méthode seuil() décrite 
    dans l'énoncé (cf. exam_jan11.pdf).
    """
    def __init__(self, *args):
        #bien que ListeChainee2 hérite de ListeChainee,
        #on est obligé d'appeler le constructeur de la classe de base.
        #Python nous permet ainsi de faire ce qu'on veut avant ou après...
        ListeChainee.__init__(self, *args)
    def seuil(self, v=False):
        """
        En gros, massacre la liste pour ne garder que les extrema locaux.
        Pour des infos plus précises, se reporter à exam-jan11.pdf
        >>> x = ListeChainee2(1, 2, 3)
        >>> x.seuil()
        >>> print x
        [3, 3, 3]
        >>> x = ListeChainee2()
        >>> x.seuil()
        >>> print x
        []
        >>> x = ListeChainee2(9, 8, 7)
        >>> x.seuil()
        >>> print x
        [7, 7, 7]
        >>> x = ListeChainee2(10, 10, 10, 1, 2, 3, 3, 3, 10)
        >>> x.seuil()
        >>> print x
        [10, 10, 10, 10, 10, 10, 10, 10, 10]
        >>> x = ListeChainee2(-9, -9, 2, 3, 3, 7, 3, 2, 3, 7, 9, 9, 7, 2, 2, 1, 0)
        >>> x.seuil()
        >>> print x
        [-9, -9, 7, 7, 7, 7, 2, 2, 9, 9, 9, 9, 0, 0, 0, 0, 0]
        >>> x = ListeChainee2(0, 1, 4, 2, 9, 7, 6, 6, 7, 7)
        >>> x.seuil()
        >>> print x
        [4, 4, 4, 9, 9, 6, 6, 6, 7, 7]
        """
        ##v=True pour passer en mode verbeux (genre d'explications)
        #Précondition (facile donc...)
        if self.head==None:
            return #rien à faire
        #Étape 1 : on skippe une éventuelle série de constantes
        p = self.head
        s = p.data #on comparera ça aux valeurs suivantes
        while p!=None and p.data==s:
            p = p.next #tant que c'est la même chose, on avance
        if self.head.next==p:
            #on n'en a skippé qu'un, donc il n'y a pas de constantes en tête.
            p = self.head #on revient au début
        #Étape 2 : on s'occupe des suites croissantes/décroissantes
        while p!=None: #tant qu'on n'est pas au bout,
            if v: print "nv serie:", p.data
            t = 0 #croissance inconnue
            b = p #début de la suite
            s = p.data #sommet local
            p = p.next
            while p!=None:
                if t==0: #première itération
                    if v: print "prem it...",
                    if p.data>s:
                        t = 2 #croissante
                        if v: print "croiss"
                    else: #ça ne peut pas être égal au début
                        t = 1 #décroissante
                        if v: print "decroiss"
                    s = p.data
                elif t==1: #suite décroissante
                    if p.data>s:
                        if v: print "fini decr", p.data
                        break #elle ne l'est plus
                    elif p.data<s:
                        if v: print "encore decr", p.data
                        s = p.data #encore plus petit
                else: #elif t==2: #suite croissante
                    if p.data<s:
                        if v: print "fini croiss", p.data
                        break #elle ne l'est plus
                    elif p.data>s:
                        if v: print "encore croiss", p.data
                        s = p.data #encore plus grand
                p = p.next
            #On écrase jusqu'avant l'endroit où on est.
            #Si on est au bout, ça ne se crashera pas...
            while b.next!=p:
                if v: print "ecrase", b.data
                b.data = s
                b = b.next


if __name__=="__main__":
    import doctest
    doctest.testmod()
